package com.wyj;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.function.Function;
import java.util.function.IntBinaryOperator;
import java.util.function.IntPredicate;

@SpringBootTest
public class lambdaTexts {


    /**
     * lambda表达式 无参的时候
     * 创建线程并启动时使用匿名内部类的时候
     */
    @Test
    void textLambda01() {

        //未使用lambda的写法 创建线程的时候
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();

        //创建线程的时候 使用lambda表达式
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        }).start();

        //当执行语句只有一条的时候 还可以这样的简写
        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();

    }

    /**
     * lambda表达式 有参的时候 两参
     * 现有方法定义如下，其中IntBinaryOperator是一个接口。先使用置名内部类的写法调用该方法。
     */
    public static int calculateNums(IntBinaryOperator operator) {
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a, b);
    }

    @Test
    void textLambda02() {
        //使用匿名内部类的写法
        int ans1 = calculateNums(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                left = left * 2;
                right = right * 2;
                return left + right;
            }
        });
        System.out.println("使用匿名内部类:");

        //使用lambda表达式  只关注参数跟代码
        int ans2 = calculateNums((int left, int right) -> {
            left = left * 2;
            right = right * 2;
            return left + right;
        });
        System.out.println("使用lambda表达式:" + ans2);

        //当参数的类型是相同的时候 也可以省略
        int ans3 = calculateNums(((left, right) -> {
            left = left * 2;
            right = right * 2;
            return left + right;
        }));
        System.out.println("简化后" + ans3);
    }


    /**
     * lambda表达式:单参
     * 现有方法定义如下，其中IntPredicate是一个接口。先使用匿名内部类的写法调用该方法。
     */
    public static void judgeNumber(IntPredicate predicate) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};

        for (int i : arr) {
            if (predicate.test(i)) {
                System.out.println(i);
            }
        }
    }

    @Test
    void textLambda03() {
        //使用匿名内部类的写法
        judgeNumber(new IntPredicate() {
            @Override
            public boolean test(int value) {
                return value % 2 == 0;
            }
        });

        //使用lambda表达式
        judgeNumber((int value) -> {
            return value % 2 == 0;
        });


        //使用lambda表达式简化写法
        judgeNumber((value -> value % 2 == 0));

    }

    /**
     * lambda表达式：现有方法定义如下，其中Function是一个接口。先使用匿名内部类的写法调用该方法。
     */
    public static  <R> R typeCover(Function<String,R> function) {
        String str = "123";
        R apply = function.apply(str);
        return apply;
    }

    @Test
    void textLambda04() {
        //匿名内部类
        Integer o = typeCover(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });

        System.out.println(o);

        //lambda表达式
        typeCover((s -> Integer.valueOf(s)));

        typeCover((s)->{
            return Integer.valueOf(s);
        });
    }


}
